การเพิ่มประสิทธิภาพสภาพแวดล้อมการพัฒนา JavaScript: การปรับแต่งประสิทธิภาพของคอนเทนเนอร์

คอนเทนเนอร์ได้ปฏิวัติการพัฒนาซอฟต์แวร์ โดยมอบสภาพแวดล้อมที่สอดคล้องและแยกส่วนสำหรับการสร้าง, ทดสอบ, และปรับใช้แอปพลิเคชัน โดยเฉพาะอย่างยิ่งกับการพัฒนา JavaScript ซึ่งการจัดการ dependency และความไม่สอดคล้องของสภาพแวดล้อมอาจเป็นความท้าทายที่สำคัญ อย่างไรก็ตาม การรันสภาพแวดล้อมการพัฒนา JavaScript ของคุณภายในคอนเทนเนอร์ไม่ได้หมายความว่าจะได้ประสิทธิภาพที่ดีขึ้นเสมอไป หากไม่มีการปรับแต่งที่เหมาะสม คอนเทนเนอร์อาจเพิ่มภาระงานและทำให้ขั้นตอนการทำงานของคุณช้าลงได้ บทความนี้จะแนะนำคุณเกี่ยวกับการเพิ่มประสิทธิภาพสภาพแวดล้อมการพัฒนา JavaScript ภายในคอนเทนเนอร์เพื่อให้ได้ประสิทธิภาพและประสิทธิผลสูงสุด

ทำไมต้องใช้คอนเทนเนอร์กับสภาพแวดล้อมการพัฒนา JavaScript ของคุณ?

ก่อนที่จะลงลึกถึงการเพิ่มประสิทธิภาพ เรามาทบทวนประโยชน์หลักของการใช้คอนเทนเนอร์สำหรับการพัฒนา JavaScript กันก่อน:

• ความสอดคล้อง: ทำให้มั่นใจได้ว่าทุกคนในทีมใช้สภาพแวดล้อมเดียวกัน ขจัดปัญหา "it works on my machine" ซึ่งรวมถึงเวอร์ชันของ Node.js, npm/yarn, dependency ของระบบปฏิบัติการ และอื่นๆ
• การแยกส่วน: ป้องกันความขัดแย้งระหว่างโปรเจกต์ต่างๆ และ dependency ของแต่ละโปรเจกต์ คุณสามารถมีหลายโปรเจกต์ที่ใช้ Node.js เวอร์ชันต่างกันทำงานพร้อมกันได้โดยไม่มีการรบกวนกัน
• การทำซ้ำได้: ทำให้ง่ายต่อการสร้างสภาพแวดล้อมการพัฒนาขึ้นมาใหม่บนเครื่องใดก็ได้ ช่วยให้การเริ่มต้นใช้งานและการแก้ไขปัญหาง่ายขึ้น
• การพกพา: ช่วยให้คุณสามารถย้ายสภาพแวดล้อมการพัฒนาของคุณไปยังแพลตฟอร์มต่างๆ ได้อย่างราบรื่น รวมถึงเครื่องคอมพิวเตอร์ส่วนตัว, เซิร์ฟเวอร์บนคลาวด์ และไปป์ไลน์ CI/CD
• ความสามารถในการขยายตัว: ทำงานร่วมกับแพลตฟอร์มการจัดการคอนเทนเนอร์อย่าง Kubernetes ได้ดี ทำให้คุณสามารถขยายสภาพแวดล้อมการพัฒนาได้ตามต้องการ

ปัญหาคอขวดด้านประสิทธิภาพที่พบบ่อยในการพัฒนา JavaScript แบบคอนเทนเนอร์

แม้จะมีข้อดี แต่ก็มีปัจจัยหลายอย่างที่อาจนำไปสู่ปัญหาคอขวดด้านประสิทธิภาพในสภาพแวดล้อมการพัฒนา JavaScript แบบคอนเทนเนอร์:

• ข้อจำกัดด้านทรัพยากร: คอนเทนเนอร์ใช้ทรัพยากรของเครื่องโฮสต์ร่วมกัน (CPU, หน่วยความจำ, ดิสก์ I/O) หากไม่ได้กำหนดค่าอย่างเหมาะสม คอนเทนเนอร์อาจถูกจำกัดการจัดสรรทรัพยากร ซึ่งนำไปสู่การทำงานที่ช้าลง
• ประสิทธิภาพของระบบไฟล์: การอ่านและเขียนไฟล์ภายในคอนเทนเนอร์อาจช้ากว่าบนเครื่องโฮสต์ โดยเฉพาะเมื่อใช้ mounted volumes
• ภาระงานของเครือข่าย: การสื่อสารผ่านเครือข่ายระหว่างคอนเทนเนอร์และเครื่องโฮสต์หรือคอนเทนเนอร์อื่นๆ อาจทำให้เกิดความล่าช้า (latency)
• เลเยอร์ของอิมเมจที่ไม่มีประสิทธิภาพ: Docker image ที่มีโครงสร้างไม่ดีอาจส่งผลให้มีขนาดใหญ่และใช้เวลาสร้างนาน
• งานที่ใช้ CPU หนัก: การแปลงโค้ดด้วย Babel, การย่อขนาดไฟล์ (minification) และกระบวนการสร้างที่ซับซ้อนอาจใช้ CPU มากและทำให้กระบวนการทั้งหมดของคอนเทนเนอร์ช้าลง

เทคนิคการเพิ่มประสิทธิภาพสำหรับคอนเทนเนอร์เพื่อการพัฒนา JavaScript

1. การจัดสรรทรัพยากรและข้อจำกัด

การจัดสรรทรัพยากรให้กับคอนเทนเนอร์ของคุณอย่างเหมาะสมเป็นสิ่งสำคัญสำหรับประสิทธิภาพ คุณสามารถควบคุมการจัดสรรทรัพยากรโดยใช้ Docker Compose หรือคำสั่ง `docker run` พิจารณาปัจจัยเหล่านี้:

• ขีดจำกัดของ CPU: จำกัดจำนวนคอร์ของ CPU ที่คอนเทนเนอร์สามารถใช้ได้โดยใช้แฟล็ก `--cpus` หรือตัวเลือก `cpus` ใน Docker Compose หลีกเลี่ยงการจัดสรรทรัพยากร CPU มากเกินไป เพราะอาจทำให้เกิดการแย่งชิงกับโปรเซสอื่นๆ บนเครื่องโฮสต์ ลองทดลองเพื่อหาจุดสมดุลที่เหมาะสมกับภาระงานของคุณ ตัวอย่าง: `--cpus="2"` หรือ `cpus: 2`
• ขีดจำกัดของหน่วยความจำ: กำหนดขีดจำกัดของหน่วยความจำโดยใช้แฟล็ก `--memory` หรือ `-m` (เช่น `--memory="2g"`) หรือตัวเลือก `mem_limit` ใน Docker Compose (เช่น `mem_limit: 2g`) ตรวจสอบให้แน่ใจว่าคอนเทนเนอร์มีหน่วยความจำเพียงพอเพื่อหลีกเลี่ยงการสลับ (swapping) ซึ่งจะทำให้ประสิทธิภาพลดลงอย่างมาก จุดเริ่มต้นที่ดีคือการจัดสรรหน่วยความจำให้มากกว่าที่แอปพลิเคชันของคุณใช้โดยทั่วไปเล็กน้อย
• การกำหนด CPU Core: ปักหมุดคอนเทนเนอร์ไว้กับ CPU core ที่ระบุโดยใช้แฟล็ก `--cpuset-cpus` ซึ่งจะช่วยปรับปรุงประสิทธิภาพโดยการลด context switching และปรับปรุง cache locality โปรดใช้ความระมัดระวังเมื่อใช้ตัวเลือกนี้ เนื่องจากอาจจำกัดความสามารถของคอนเทนเนอร์ในการใช้ทรัพยากรที่มีอยู่ได้เช่นกัน ตัวอย่าง: `--cpuset-cpus="0,1"`

ตัวอย่าง (Docker Compose):

version: "3.8"
services:
  web:
    image: node:16
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    working_dir: /app
    command: npm start
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 2g

2. การเพิ่มประสิทธิภาพของระบบไฟล์

ประสิทธิภาพของระบบไฟล์มักเป็นปัญหาคอขวดที่สำคัญในสภาพแวดล้อมการพัฒนาแบบคอนเทนเนอร์ นี่คือเทคนิคบางอย่างเพื่อปรับปรุงประสิทธิภาพ:

• การใช้ Named Volumes: แทนที่จะใช้ bind mounts (การเมาท์ไดเรกทอรีโดยตรงจากโฮสต์) ให้ใช้ named volumes ซึ่ง Docker จะเป็นผู้จัดการและสามารถให้ประสิทธิภาพที่ดีกว่า Bind mounts มักมีภาระงานด้านประสิทธิภาพเนื่องจากการแปลงระบบไฟล์ระหว่างโฮสต์และคอนเทนเนอร์
• การตั้งค่าประสิทธิภาพของ Docker Desktop: หากคุณใช้ Docker Desktop (บน macOS หรือ Windows) ให้ปรับการตั้งค่าการแชร์ไฟล์ Docker Desktop ใช้เครื่องเสมือน (virtual machine) เพื่อรันคอนเทนเนอร์ และการแชร์ไฟล์ระหว่างโฮสต์และ VM อาจช้า ลองทดลองใช้โปรโตคอลการแชร์ไฟล์ต่างๆ (เช่น gRPC FUSE, VirtioFS) และเพิ่มทรัพยากรที่จัดสรรให้กับ VM
• Mutagen (macOS/Windows): ลองพิจารณาใช้ Mutagen ซึ่งเป็นเครื่องมือซิงโครไนซ์ไฟล์ที่ออกแบบมาโดยเฉพาะเพื่อปรับปรุงประสิทธิภาพของระบบไฟล์ระหว่างโฮสต์และคอนเทนเนอร์ Docker บน macOS และ Windows โดยจะซิงโครไนซ์ไฟล์ในเบื้องหลัง ทำให้ได้ประสิทธิภาพใกล้เคียงกับระดับเนทีฟ
• การเมาท์แบบ tmpfs: สำหรับไฟล์หรือไดเรกทอรีชั่วคราวที่ไม่ต้องบันทึกถาวร ให้ใช้การเมาท์แบบ `tmpfs` ซึ่งจะเก็บไฟล์ไว้ในหน่วยความจำ ทำให้เข้าถึงได้รวดเร็วมาก ซึ่งมีประโยชน์อย่างยิ่งสำหรับ `node_modules` หรือผลลัพธ์จากการ build ตัวอย่าง: `volumes: - myvolume:/path/in/container:tmpfs`
• หลีกเลี่ยง I/O ไฟล์ที่มากเกินไป: ลดปริมาณการ I/O ไฟล์ที่เกิดขึ้นภายในคอนเทนเนอร์ ซึ่งรวมถึงการลดจำนวนไฟล์ที่เขียนลงดิสก์ การปรับขนาดไฟล์ให้เหมาะสม และการใช้แคช

ตัวอย่าง (Docker Compose with Named Volume):

version: "3.8"
services:
  web:
    image: node:16
    ports:
      - "3000:3000"
    volumes:
      - app_data:/app
    working_dir: /app
    command: npm start
volumes:
  app_data:

ตัวอย่าง (Docker Compose with Mutagen - requires Mutagen to be installed and configured):

version: "3.8"
services:
  web:
    image: node:16
    ports:
      - "3000:3000"
    volumes:
      - mutagen:/app
    working_dir: /app
    command: npm start
volumes:
  mutagen:
    driver: mutagen

3. การเพิ่มประสิทธิภาพขนาดอิมเมจและเวลาในการสร้างของ Docker

Docker image ที่มีขนาดใหญ่อาจทำให้ใช้เวลาในการสร้างนานขึ้น เพิ่มค่าใช้จ่ายในการจัดเก็บ และทำให้การปรับใช้ช้าลง นี่คือเทคนิคบางอย่างเพื่อลดขนาดอิมเมจและปรับปรุงเวลาในการสร้าง:

• การสร้างแบบหลายขั้นตอน (Multi-Stage Builds): ใช้การสร้างแบบหลายขั้นตอนเพื่อแยกสภาพแวดล้อมการสร้าง (build environment) ออกจากสภาพแวดล้อมการทำงาน (runtime environment) ซึ่งช่วยให้คุณสามารถรวมเครื่องมือสร้างและ dependency ไว้ในขั้นตอนการสร้างโดยไม่ต้องรวมไว้ในอิมเมจสุดท้าย ทำให้ขนาดของอิมเมจสุดท้ายลดลงอย่างมาก
• ใช้ Base Image ที่เล็กที่สุด: เลือก base image ที่เล็กที่สุดสำหรับคอนเทนเนอร์ของคุณ สำหรับแอปพลิเคชัน Node.js ลองพิจารณาใช้ `node:alpine` image ซึ่งมีขนาดเล็กกว่า `node` image มาตรฐานอย่างมาก Alpine Linux เป็นดิสทริบิวชันน้ำหนักเบาที่มีขนาดเล็ก
• การจัดลำดับเลเยอร์ให้เหมาะสม: จัดลำดับคำสั่งใน Dockerfile ของคุณเพื่อใช้ประโยชน์จากแคชเลเยอร์ของ Docker วางคำสั่งที่มีการเปลี่ยนแปลงบ่อย (เช่น การคัดลอกโค้ดแอปพลิเคชัน) ไว้ท้ายๆ ของ Dockerfile และวางคำสั่งที่มีการเปลี่ยนแปลงน้อยกว่า (เช่น การติดตั้ง dependency ของระบบ) ไว้ตอนต้น ซึ่งช่วยให้ Docker สามารถนำเลเยอร์ที่แคชไว้มาใช้ซ้ำได้ ทำให้การสร้างครั้งต่อไปเร็วขึ้นอย่างมาก
• ลบไฟล์ที่ไม่จำเป็นออก: ลบไฟล์ที่ไม่จำเป็นออกจากอิมเมจหลังจากที่ไม่ได้ใช้แล้ว ซึ่งรวมถึงไฟล์ชั่วคราว, ผลลัพธ์จากการ build และเอกสารต่างๆ ใช้คำสั่ง `rm` หรือการสร้างแบบหลายขั้นตอนเพื่อลบไฟล์เหล่านี้
• ใช้ .dockerignore: สร้างไฟล์ `.dockerignore` เพื่อยกเว้นไฟล์และไดเรกทอรีที่ไม่จำเป็นออกจากการคัดลอกไปยังอิมเมจ ซึ่งจะช่วยลดขนาดอิมเมจและเวลาในการสร้างได้อย่างมาก ยกเว้นไฟล์ต่างๆ เช่น `node_modules`, `.git` และไฟล์ขนาดใหญ่อื่นๆ ที่ไม่เกี่ยวข้อง

ตัวอย่าง (Dockerfile with Multi-Stage Build):

# Stage 1: Build the application
FROM node:16 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Stage 2: Create the runtime image
FROM node:16-alpine
WORKDIR /app
COPY --from=builder /app/dist .  # Copy only the built artifacts
COPY package*.json ./
RUN npm install --production  # Install only production dependencies
CMD ["npm", "start"]

4. การเพิ่มประสิทธิภาพเฉพาะสำหรับ Node.js

การเพิ่มประสิทธิภาพแอปพลิเคชัน Node.js ของคุณเองก็สามารถปรับปรุงประสิทธิภาพภายในคอนเทนเนอร์ได้เช่นกัน:

• ใช้โหมด Production: รันแอปพลิเคชัน Node.js ของคุณในโหมด production โดยการตั้งค่าตัวแปรสภาพแวดล้อม `NODE_ENV` เป็น `production` ซึ่งจะปิดใช้งานฟีเจอร์สำหรับช่วงพัฒนา เช่น การดีบักและ hot reloading ซึ่งจะช่วยปรับปรุงประสิทธิภาพ
• เพิ่มประสิทธิภาพ Dependencies: ใช้ `npm prune --production` หรือ `yarn install --production` เพื่อติดตั้งเฉพาะ dependency ที่จำเป็นสำหรับ production เท่านั้น dependency สำหรับการพัฒนาสามารถเพิ่มขนาดของไดเรกทอรี `node_modules` ของคุณได้อย่างมาก
• การแบ่งโค้ด (Code Splitting): ใช้การแบ่งโค้ดเพื่อลดเวลาในการโหลดเริ่มต้นของแอปพลิเคชันของคุณ เครื่องมืออย่าง Webpack และ Parcel สามารถแบ่งโค้ดของคุณออกเป็นส่วนเล็กๆ ที่จะถูกโหลดเมื่อต้องการโดยอัตโนมัติ
• การแคช (Caching): ใช้กลไกการแคชเพื่อลดจำนวนการร้องขอไปยังเซิร์ฟเวอร์ของคุณ ซึ่งสามารถทำได้โดยใช้แคชในหน่วยความจำ, แคชภายนอกอย่าง Redis หรือ Memcached หรือการแคชของเบราว์เซอร์
• การทำโปรไฟล์ (Profiling): ใช้เครื่องมือทำโปรไฟล์เพื่อระบุปัญหาคอขวดด้านประสิทธิภาพในโค้ดของคุณ Node.js มีเครื่องมือทำโปรไฟล์ในตัวที่สามารถช่วยคุณระบุฟังก์ชันที่ทำงานช้าและเพิ่มประสิทธิภาพโค้ดของคุณได้
• เลือกเวอร์ชัน Node.js ที่เหมาะสม: Node.js เวอร์ชันใหม่ๆ มักมีการปรับปรุงประสิทธิภาพและการเพิ่มประสิทธิภาพรวมอยู่ด้วย อัปเดตเป็นเวอร์ชันเสถียรล่าสุดอย่างสม่ำเสมอ

ตัวอย่าง (Setting NODE_ENV in Docker Compose):

version: "3.8"
services:
  web:
    image: node:16
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    working_dir: /app
    command: npm start
    environment:
      NODE_ENV: production

5. การเพิ่มประสิทธิภาพเครือข่าย

การสื่อสารผ่านเครือข่ายระหว่างคอนเทนเนอร์และเครื่องโฮสต์ก็อาจส่งผลต่อประสิทธิภาพได้ นี่คือเทคนิคการเพิ่มประสิทธิภาพบางประการ:

• ใช้ Host Networking (อย่างระมัดระวัง): ในบางกรณี การใช้ตัวเลือก `--network="host"` สามารถปรับปรุงประสิทธิภาพได้โดยการกำจัดภาระงานของ network virtualization อย่างไรก็ตาม วิธีนี้จะเปิดเผยพอร์ตของคอนเทนเนอร์โดยตรงกับเครื่องโฮสต์ ซึ่งอาจสร้างความเสี่ยงด้านความปลอดภัยและความขัดแย้งของพอร์ตได้ ใช้ตัวเลือกนี้ด้วยความระมัดระวังและเฉพาะเมื่อจำเป็นเท่านั้น
• DNS ภายใน: ใช้ DNS ภายในของ Docker เพื่อแก้ไขชื่อคอนเทนเนอร์แทนที่จะพึ่งพาเซิร์ฟเวอร์ DNS ภายนอก ซึ่งจะช่วยลดความล่าช้าและปรับปรุงความเร็วในการแก้ไขเครือข่าย
• ลดจำนวนการร้องขอผ่านเครือข่าย: ลดจำนวนการร้องขอผ่านเครือข่ายที่แอปพลิเคชันของคุณทำ ซึ่งสามารถทำได้โดยการรวมคำขอหลายรายการเป็นคำขอเดียว, การแคชข้อมูล และการใช้รูปแบบข้อมูลที่มีประสิทธิภาพ

6. การตรวจสอบและการทำโปรไฟล์

ตรวจสอบและทำโปรไฟล์สภาพแวดล้อมการพัฒนา JavaScript แบบคอนเทนเนอร์ของคุณอย่างสม่ำเสมอเพื่อระบุปัญหาคอขวดด้านประสิทธิภาพและเพื่อให้แน่ใจว่าการเพิ่มประสิทธิภาพของคุณได้ผล

• Docker Stats: ใช้คำสั่ง `docker stats` เพื่อตรวจสอบการใช้ทรัพยากรของคอนเทนเนอร์ของคุณ รวมถึง CPU, หน่วยความจำ และ network I/O
• เครื่องมือทำโปรไฟล์: ใช้เครื่องมือทำโปรไฟล์ เช่น Node.js inspector หรือ Chrome DevTools เพื่อทำโปรไฟล์โค้ด JavaScript ของคุณและระบุปัญหาคอขวดด้านประสิทธิภาพ
• การบันทึกข้อมูล (Logging): ใช้การบันทึกข้อมูลที่ครอบคลุมเพื่อติดตามพฤติกรรมของแอปพลิเคชันและระบุปัญหาที่อาจเกิดขึ้น ใช้ระบบบันทึกข้อมูลแบบรวมศูนย์เพื่อรวบรวมและวิเคราะห์ล็อกจ์จากคอนเทนเนอร์ทั้งหมด
• การตรวจสอบผู้ใช้จริง (Real User Monitoring - RUM): ใช้ RUM เพื่อตรวจสอบประสิทธิภาพของแอปพลิเคชันของคุณจากมุมมองของผู้ใช้จริง ซึ่งจะช่วยให้คุณสามารถระบุปัญหาด้านประสิทธิภาพที่มองไม่เห็นในสภาพแวดล้อมการพัฒนาได้

ตัวอย่าง: การเพิ่มประสิทธิภาพสภาพแวดล้อมการพัฒนา React ด้วย Docker

เรามาดูตัวอย่างเทคนิคเหล่านี้ด้วยตัวอย่างจริงของการเพิ่มประสิทธิภาพสภาพแวดล้อมการพัฒนา React โดยใช้ Docker

1. การตั้งค่าเริ่มต้น (ประสิทธิภาพช้า): Dockerfile พื้นฐานที่คัดลอกไฟล์โปรเจกต์ทั้งหมด, ติดตั้ง dependency และเริ่มเซิร์ฟเวอร์การพัฒนา ซึ่งมักจะประสบปัญหาเวลาสร้างช้าและปัญหาประสิทธิภาพของระบบไฟล์เนื่องจาก bind mounts
2. Dockerfile ที่ปรับให้เหมาะสม (สร้างเร็วขึ้น, อิมเมจเล็กลง): การใช้ multi-stage builds เพื่อแยกสภาพแวดล้อมการสร้างและการทำงาน ใช้ `node:alpine` เป็น base image การจัดลำดับคำสั่ง Dockerfile เพื่อการแคชที่ดีที่สุด ใช้ `.dockerignore` เพื่อยกเว้นไฟล์ที่ไม่จำเป็น
3. การกำหนดค่า Docker Compose (การจัดสรรทรัพยากร, Named Volumes): การกำหนดขีดจำกัดทรัพยากรสำหรับ CPU และหน่วยความจำ การเปลี่ยนจาก bind mounts เป็น named volumes เพื่อปรับปรุงประสิทธิภาพของระบบไฟล์ อาจจะรวม Mutagen เข้าไปด้วยหากใช้ Docker Desktop
4. การเพิ่มประสิทธิภาพ Node.js (เซิร์ฟเวอร์การพัฒนาที่เร็วขึ้น): การตั้งค่า `NODE_ENV=development` การใช้ตัวแปรสภาพแวดล้อมสำหรับ API endpoints และพารามิเตอร์การกำหนดค่าอื่นๆ การใช้กลยุทธ์การแคชเพื่อลดภาระของเซิร์ฟเวอร์

สรุป

การเพิ่มประสิทธิภาพสภาพแวดล้อมการพัฒนา JavaScript ของคุณภายในคอนเทนเนอร์ต้องใช้วิธีการที่หลากหลาย ด้วยการพิจารณาอย่างรอบคอบเกี่ยวกับการจัดสรรทรัพยากร, ประสิทธิภาพของระบบไฟล์, ขนาดอิมเมจ, การเพิ่มประสิทธิภาพเฉพาะสำหรับ Node.js และการกำหนดค่าเครือข่าย คุณสามารถปรับปรุงประสิทธิภาพและประสิทธิผลได้อย่างมาก อย่าลืมตรวจสอบและทำโปรไฟล์สภาพแวดล้อมของคุณอย่างต่อเนื่องเพื่อระบุและแก้ไขปัญหาคอขวดที่เกิดขึ้นใหม่ ด้วยการใช้เทคนิคเหล่านี้ คุณสามารถสร้างประสบการณ์การพัฒนาที่เร็วขึ้น, เชื่อถือได้มากขึ้น และสอดคล้องกันมากขึ้นสำหรับทีมของคุณ ซึ่งจะนำไปสู่ผลิตภาพที่สูงขึ้นและคุณภาพซอฟต์แวร์ที่ดีขึ้นในที่สุด การใช้คอนเทนเนอร์เมื่อทำอย่างถูกต้องแล้วจะเป็นประโยชน์อย่างยิ่งสำหรับการพัฒนา JS

นอกจากนี้ ลองพิจารณาสำรวจเทคนิคขั้นสูง เช่น การใช้ BuildKit สำหรับการสร้างแบบขนาน และสำรวจ container runtimes ทางเลือกอื่นๆ เพื่อเพิ่มประสิทธิภาพให้ดียิ่งขึ้น